

// paraCFG@UDP 为默认配置(出厂设置)  paraCFG@UDC 为默认配置区。为保证两个默认配置一致，故在此处统一初始化

#if defined(UDP_CFG_ENABLE)
	.paraANA.ana1.ana_cfg0   = UDPCFG_ANA1_CFG0,
	.paraANA.ana1.ana_cfg1   = UDPCFG_ANA1_CFG1,
	.paraANA.ana1.ana_cfg2   = UDPCFG_ANA1_CFG2,

	.paraANA.ana2.ana_cfg0   = UDPCFG_ANA2_CFG0,
	.paraANA.ana2.ana_cfg1   = UDPCFG_ANA2_CFG1,
	.paraANA.ana2.ana_cfg2   = UDPCFG_ANA2_CFG2,

	.paraANA.ana3.ana_cfg0   = UDPCFG_ANA3_CFG0,
	.paraANA.ana3.ana_cfg1   = UDPCFG_ANA3_CFG1,
	.paraANA.ana3.ana_cfg2   = UDPCFG_ANA3_CFG2,

	.paraANA.ana4.ana_cfg0   = UDPCFG_ANA4_CFG0,
	.paraANA.ana4.ana_cfg1   = UDPCFG_ANA4_CFG1,
	.paraANA.ana4.ana_cfg2   = UDPCFG_ANA4_CFG2,

	.paraANA.ramp_pll_cfg    = UDPCFG_RAMP_PLL,       //freq start  24.01G
	.paraANA.ramp_syncw_cfg  = UDPCFG_SYNCW,          //sync  3210
	.paraANA.ramp_chirpw_cfg = UDPCFG_CHIRPW,         //acc   210
	.paraANA.ramp_wm_cfg0    = UDPCFG_RAMP_WM,        //circle mode

	.paraANA.ramp_mem03      = UDPCFG_RAMP_WAVE0_A,   //A: 10us     0G
	.paraANA.ramp_mem02      = UDPCFG_RAMP_WAVE0_B,   //B: 30us  0.22G
	.paraANA.ramp_mem01      = UDPCFG_RAMP_WAVE0_C,   //c: 30us -0.22G
	.paraANA.ramp_mem00      = UDFDEF_RAMP_WAVE0_R,

	.paraANA.ramp_mem13      = UDPCFG_RAMP_WAVE1_A,   //A:  10us     0G
	.paraANA.ramp_mem12      = UDPCFG_RAMP_WAVE1_B,   //B: 110us  0.22G
	.paraANA.ramp_mem11      = UDPCFG_RAMP_WAVE1_C,   //c:  30us -0.22G
	.paraANA.ramp_mem10      = UDFDEF_RAMP_WAVE1_R,

	.paraANA.crcLen          = sizeof( PARAM_ANA_VENUS ) - 4,
	.paraANA.crcVal          = UDP_ANA_CRC,


/************************************paramDataPrep***************************************/
	#if UDFDEF_ANT_NUM > 1
	.paraDataPrep.calibAnt2_r            = UDFDEF_ANT2_CALIB_R,
	.paraDataPrep.calibAnt2_i            = UDFDEF_ANT2_CALIB_I,
	#endif

	.paraDataPrep.angleDstAddr           = GET_OFFSET( UDFDEF_ADDR_ANGLE_ARRAY ),
	.paraDataPrep.angleFlashLen          = NUM_ANGLE * UDFDEF_ANT_NUM * NUM_BYTE32,

	.paraDataPrep.winRange.len           = UDFDEF_ADCSAMP_NUM,
	.paraDataPrep.winRange.srcInc        = 2 * 256 / UDFDEF_ADCSAMP_NUM,
	.paraDataPrep.winRange.dstOffsetAddr = GET_OFFSET( UDFDEF_ADDR_WIN_RANGE ),
	.paraDataPrep.winRange.dstInc        = 2,

	.paraDataPrep.winVel.len             = UDFDEF_CHIRP_NUM,
	.paraDataPrep.winVel.dstOffsetAddr   = GET_OFFSET( UDFDEF_ADDR_WIN_VEL ),
	.paraDataPrep.winVel.srcInc          = 2 * 256 / UDFDEF_CHIRP_NUM,
	.paraDataPrep.winVel.dstInc          = 2,

	#if (UDFDEF_ANT_NUM > 1) && !defined(RADAR_USE_ANT1_AND_ANT2)
		#if !defined(FLASH_WINRANGE) && !defined(FLASH_WINVEL)
		.paraDataPrep.constEn = CONST_WINRANGE_EN | CONST_WINVEL_EN | CONST_ANGLE_EN,
		#elif !defined(FLASH_WINRANGE)
		.paraDataPrep.constEn = CONST_WINRANGE_EN | CONST_ANGLE_EN,
		#elif !defined(FLASH_WINVEL)
		.paraDataPrep.constEn = CONST_WINVEL_EN | CONST_ANGLE_EN,
		#else
		.paraDataPrep.constEn = CONST_ANGLE_EN,
		#endif
	#else
		#if !defined(FLASH_WINRANGE) && !defined(FLASH_WINVEL)
		.paraDataPrep.constEn = CONST_WINRANGE_EN | CONST_WINVEL_EN,
		#elif !defined(FLASH_WINRANGE)
		.paraDataPrep.constEn = CONST_WINRANGE_EN,
		#elif !defined(FLASH_WINVEL)
		.paraDataPrep.constEn = CONST_WINVEL_EN,
		#else
		.paraDataPrep.constEn = 0,
		#endif
	#endif

	#if SDK_VERSION < SDK_VERSION_GENE(3,0)
	.paraDataPrep.constFlashEn = 0,
	#endif

	.paraDataPrep.prepCfg0 = UDPCFG_DP_CFG0,
	.paraDataPrep.prepCfg1 = UDPCFG_DP_CFG1,
	.paraDataPrep.prepCfg2 = UDPCFG_DP_CFG2,

	.paraDataPrep.cycleNum = UDFDEF_CYCLE_NUM,

	.paraDataPrep.crcLen = sizeof( PARAM_DATAPREP ) - 4,
	.paraDataPrep.crcVal = UDP_DATAPREP_CRC,

/*************************************************paramALG***********************************/
#if 1 /*alg0 chirpsum */
	/*alg0*/ //chirpsum
	// intraCnt,fix2pfLsfB,max_clr,p2_fft_mode,dma_dsize,rsfBit,sub_mode,mode
	.paraALG.alg0.p2Cfg0 = ( UDFDEF_CHIRP_SUM_NUM - 1 ) << 20 |
	P2_FIX2PF_LSFB_0BIT << 17 |
	P2_MAX_CLR_EN << 16 |
	P2_FFT_MODE_DIS << 14 |
	P2_DMA_DSIZE_8BIT << 12 |
	P2_RSF_DIV1 << 8 |
	P2_SUBMODE_0 << 4 |
	P2_MODE_ACC,
	// jumpCnt,interCnt
	.paraALG.alg0.p2Cfg1 = ( UDFDEF_ANT_NUM - 1 ) << 12 | ( UDFDEF_ADCSAMP_NUM - 1 ) << 0,
	// ncoMode,nco_fcw
	.paraALG.alg0.p2Cfg2 = ( 0 ) << 24 | ( 0 ) << 0,
	// src0JumpInc,src0InterInc
	.paraALG.alg0.p2Cfg3 = ( NUM_BYTE8*UDFDEF_ADCSAMP_NUM ) << 16 | ( NUM_BYTE8 ) << 0,
	// src0IntraInc,src0BaseAddr
	.paraALG.alg0.p2Cfg4 = ( NUM_BYTE8*UDFDEF_ADCSAMP_NUM*UDFDEF_ANT_NUM ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_ADCSAMP ) ) << 0,
	// src1JumpInc,src1InterInc
	.paraALG.alg0.p2Cfg5 = ( 0 ) << 16 | ( 0 ) << 0,
	// src1IntraInc,src1BaseAddr
	.paraALG.alg0.p2Cfg6 = ( 0 ) << 16 | ( 0 ) << 0,
	// dstJumpInc,dstInterInc
	.paraALG.alg0.p2Cfg7 = ( UDFDEF_ADCSAMP_NUM*NUM_BYTE32 ) << 16 | ( NUM_BYTE32 ) << 0,
	// dstIntraInc,dstBaseAddr
	.paraALG.alg0.p2Cfg8 = ( NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_CHIRPSUM ) ) << 0,
	.paraALG.alg0.dstInc = NUM_BYTE32,
#endif

//  #if 1 /*alg1 fft1d */
//  //intraCnt,fix2pfLsfB,max_clr,p2_fft_mode,dma_dsize,rsfBit,sub_mode,mode
//  .paraALG.alg1.p2Cfg0 = (UDFDEF_ADCSAMP_NUM-1)<< 20|
//                                                  P2_FIX2PF_LSFB_0BIT<<17|
//                                                  P2_MAX_CLR_EN<<16 |
//                                                  P2_FFT_MODE_EN<<14|
//                                                  P2_DMA_DSIZE_32BIT<<12|
//                                                  P2_RSF_DIV1<<8|
//                                                  P2_SUBMODE_0<<4|
//                                                  P2_MODE_DMA,
//  //jumpCnt,interCnt
//  .paraALG.alg1.p2Cfg1 = (UDFDEF_CHIRP_NUM-1)<< 12 | (UDFDEF_ANT_NUM-1)<<0,
//  //ncoMode,nco_fcw
//  .paraALG.alg1.p2Cfg2 = (0)<< 24 |(0)<< 0,
//  //src0JumpInc,src0InterInc
//  .paraALG.alg1.p2Cfg3 = (UDFDEF_ADCSAMP_NUM*NUM_BYTE32*UDFDEF_ANT_NUM)<<16 |(UDFDEF_ADCSAMP_NUM*NUM_BYTE32)<<0,
//  //src0IntraInc,src0BaseAddr
//  .paraALG.alg1.p2Cfg4 = (NUM_BYTE32)<<16 |(GET_OFFSET(UDFDEF_ADDR_CHIRPSUM))<< 0,
//  //src1JumpInc,src1InterInc
//  .paraALG.alg1.p2Cfg5 = (0)<<16 |(0)<< 0,
//  //src1IntraInc,src1BaseAddr
//  .paraALG.alg1.p2Cfg6 = (0)<<16 |(0)<< 0,
//  //dstJumpInc,dstInterInc
//  .paraALG.alg1.p2Cfg7 = (UDFDEF_RANGE_USE*NUM_BYTE32)<<16 |(UDFDEF_ADDR_FFT1D_ANT2-UDFDEF_ADDR_FFT1D_ANT1)<<0,
//  //dstIntraInc,dstBaseAddr
//  .paraALG.alg1.p2Cfg8 = (NUM_BYTE32)<<16 |(GET_OFFSET(UDFDEF_ADDR_FFT1D_ANT1))<< 0,
//
//  //inPt,fftPt,mode
//  .paraALG.alg1.fftCfg0 = (UDFDEF_ADCSAMP_NUM - 1) << 8 | (UDFDEF_FFT_PT) << 4 | (FFT_MODE_FORWARD) << 0,
//  //useA,useB
//  .paraALG.alg1.fftCfg1 = (0) << 8 | (UDFDEF_RANGE_USE- 1) << 0,
//  //winBaseAddr,winSize,winEn
//  #ifdef WINRANGE_ENABLE
//  .paraALG.alg1.fftCfg2 = (uint32_t)(GET_OFFSET(UDFDEF_ADDR_WIN_RANGE)) << 16 | (FFT_WIN_SIZE_14BIT) << 1 | (FFT_WIN_EN) << 0,
//  #else
//  .paraALG.alg1.fftCfg2 = (uint32_t)(GET_OFFSET(UDFDEF_ADDR_WIN_RANGE)) << 16 | (FFT_WIN_SIZE_14BIT) << 1 | (FFT_WIN_DIS) << 0,
//  #endif
//  #endif

	#if 1 /*alg1 fft1d */
				//intraCnt,fix2pfLsfB,max_clr,p2_fft_mode,dma_dsize,rsfBit,sub_mode,mode
		.paraALG.alg1.p2Cfg0 = ( UDFDEF_ADCSAMP_NUM - 1 ) << 20 |
		P2_FIX2PF_LSFB_0BIT << 17 |
		P2_MAX_CLR_EN << 16 |
		P2_FFT_MODE_EN << 14 |
		P2_DMA_DSIZE_32BIT << 12 |
		P2_RSF_DIV1 << 8 |
		P2_SUBMODE_0 << 4 |
		P2_MODE_DMA,
		//jumpCnt,interCnt
		.paraALG.alg1.p2Cfg1 = ( UDFDEF_ANT_NUM - 1 ) << 12 | ( 0 ) << 0,
		//ncoMode,nco_fcw
		.paraALG.alg1.p2Cfg2 = ( 0 ) << 24 | ( 0 ) << 0,
		//src0JumpInc,src0InterInc
		.paraALG.alg1.p2Cfg3 = ( UDFDEF_ADCSAMP_NUM*NUM_BYTE32 ) << 16 | ( 0 ) << 0,
		//src0IntraInc,src0BaseAddr
		.paraALG.alg1.p2Cfg4 = ( NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_CHIRPSUM )  ) << 0,
		//src1JumpInc,src1InterInc
		.paraALG.alg1.p2Cfg5 = ( 0 ) << 16 | ( 0 ) << 0,
		//src1IntraInc,src1BaseAddr
		.paraALG.alg1.p2Cfg6 = ( 0 ) << 16 | ( 0 ) << 0,
		//dstJumpInc,dstInterInc
		.paraALG.alg1.p2Cfg7 = ( UDFDEF_RANGE_USE*NUM_BYTE32 ) << 16 | ( 0 ) << 0,
		//dstIntraInc,dstBaseAddr
		.paraALG.alg1.p2Cfg8 = ( NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_FFT1D_ANT1 ) ) << 0,

		//inPt,fftPt,mode
		.paraALG.alg1.fftCfg0 = ( UDFDEF_ADCSAMP_NUM - 1 ) << 8 | ( FFT_PT256 ) << 4 | ( FFT_MODE_FORWARD ) << 0,
		//useA,useB
		.paraALG.alg1.fftCfg1 = ( 0 ) << 8 | ( UDFDEF_RANGE_USE - 1 ) << 0,
		//winBaseAddr,winSize,winEn
		#ifdef WINRANGE_ENABLE
		.paraALG.alg1.fftCfg2 = ( uint32_t )( GET_OFFSET( UDFDEF_ADDR_WIN_RANGE ) ) << 16 | ( FFT_WIN_SIZE_14BIT ) << 1 | ( FFT_WIN_EN ) << 0,
		#else
		.paraALG.alg1.fftCfg2 = ( uint32_t )( GET_OFFSET( UDFDEF_ADDR_WIN_RANGE ) ) << 16 | ( FFT_WIN_SIZE_14BIT ) << 1 | ( FFT_WIN_DIS ) << 0,
		#endif
	#endif

//  #if 1 /*alg2 fft1d mean */
//  //intraCnt,fix2pfLsfB,max_clr,p2_fft_mode,dma_dsize,rsfBit,sub_mode,mode
//  .paraALG.alg2.p2Cfg0 = (UDFDEF_CHIRP_NUM-1)<< 20|
//                                                  P2_FIX2PF_LSFB_0BIT<<17|
//                                                  P2_MAX_CLR_EN<<16 |
//                                                  P2_FFT_MODE_DIS<<14|
//                                                  P2_DMA_DSIZE_32BIT<<12|
//                                                  #if (UDFDEF_CHIRP_NUM == 32 )
//                                                  P2_RSF_DIV32<<8|
//                                                  #elif (UDFDEF_CHIRP_NUM == 16 )
//                                                  P2_RSF_DIV16<<8|
//                                                  #elif (UDFDEF_CHIRP_NUM == 8 )
//                                                  P2_RSF_DIV8<<8|
//                                                  #elif (UDFDEF_CHIRP_NUM == 4 )
//                                                  P2_RSF_DIV4<<8|
//                                                  #elif (UDFDEF_CHIRP_NUM == 2 )
//                                                  P2_RSF_DIV2<<8|
//                                                  #else
//                                                  #error unxxx
//                                                  #endif
//                                                  P2_SUBMODE_0<<4|
//                                                  P2_MODE_ACC,
//  //jumpCnt,interCnt
//  .paraALG.alg2.p2Cfg1 = (UDFDEF_ANT_NUM-1)<< 12 |(UDFDEF_RANGE_USE-1)<< 0,
//  //ncoMode,nco_fcw
//  .paraALG.alg2.p2Cfg2 = (0)<< 24 |(0)<< 0,
//  //src0JumpInc,src0InterInc
//  .paraALG.alg2.p2Cfg3 = (UDFDEF_ADDR_FFT1D_ANT2-UDFDEF_ADDR_FFT1D_ANT1)<<16 |(NUM_BYTE32)<< 0,
//  //src0IntraInc,src0BaseAddr
//  .paraALG.alg2.p2Cfg4 = (UDFDEF_RANGE_USE*NUM_BYTE32)<<16 |(GET_OFFSET(UDFDEF_ADDR_FFT1D_ANT1))<< 0,
//  //src1JumpInc,src1InterInc
//  .paraALG.alg2.p2Cfg5 = (0)<<16 |(0)<< 0,
//  //src1IntraInc,src1BaseAddr
//  .paraALG.alg2.p2Cfg6 = (0)<<16 |(0)<< 0,
//  //dstJumpInc,dstInterInc
//  .paraALG.alg2.p2Cfg7 = (UDFDEF_ADDR_FFT1D_MEAN_ANT2-UDFDEF_ADDR_FFT1D_MEAN_ANT1)<<16 |(NUM_BYTE32)<< 0,
//  //dstIntraInc,dstBaseAddr
//  .paraALG.alg2.p2Cfg8 = (0)<<16 |(GET_OFFSET(UDFDEF_ADDR_FFT1D_MEAN_ANT1))<< 0,
//  #endif
#if 1 /*alg3 fft1d minus */
	// intraCnt,fix2pfLsfB,max_clr,p2_fft_mode,dma_dsize,rsfBit,sub_mode,mode
	.paraALG.alg3.p2Cfg0 = ( UDFDEF_RANGE_USE - 1 ) << 20 |
	P2_FIX2PF_LSFB_0BIT << 17 |
	P2_MAX_CLR_EN << 16 |
	P2_FFT_MODE_DIS << 14 |
	P2_DMA_DSIZE_32BIT << 12 |
	P2_RSF_DIV1 << 8 |
	P2_SUBMODE_2 << 4 |
	P2_MODE_ADD,
	//jumpCnt,interCnt
	.paraALG.alg3.p2Cfg1 = ( UDFDEF_ANT_NUM-1 ) << 12 | ( 0 ) << 0,
	//ncoMode,nco_fcw
	.paraALG.alg3.p2Cfg2 = ( 0 ) << 24 | ( 0 ) << 0,
	//src0JumpInc,src0InterInc
	.paraALG.alg3.p2Cfg3 = ( UDFDEF_RANGE_USE*NUM_BYTE32 ) << 16 | ( 0 ) << 0,
	//src0IntraInc,src0BaseAddr
	.paraALG.alg3.p2Cfg4 = ( NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_FFT1D_ANT1 ) ) << 0,
	//src1JumpInc,src1InterInc
	.paraALG.alg3.p2Cfg5 = ( UDFDEF_RANGE_USE*NUM_BYTE32 ) << 16 | ( 0 ) << 0,
	//src1IntraInc,src1BaseAddr
	.paraALG.alg3.p2Cfg6 = ( NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_FRAME_RECOVER_FFT1D_OLD ) ) << 0,
	//dstJumpInc,dstInterInc
	//  .paraALG.alg2.p2Cfg7 = (UDFDEF_RANGE_USE*NUM_BYTE32)<<16 |(UDFDEF_RANGE_USE*UDFDEF_ANT_NUM*NUM_BYTE32)<< 0,
	.paraALG.alg3.p2Cfg7 = ( UDFDEF_RANGE_USE *NUM_BYTE32) << 16 | ( 0 ) << 0,
	//dstIntraInc,dstBaseAddr
	.paraALG.alg3.p2Cfg8 = ( NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_FFT1D_MINUS ) ) << 0,
#endif

//  #if 1 /*alg3*/ // fft2d ant1
//  .paraALG.alg3.p2Cfg0 = (UDFDEF_CHIRP_NUM-1)<< 20|
//                      P2_FIX2PF_LSFB_0BIT<<17|
//                      P2_MAX_CLR_EN<<16 |
//                      P2_FFT_MODE_EN<<14|
//                      P2_DMA_DSIZE_32BIT<<12|
//                      P2_RSF_DIV1<<8|
//  #if FFT2D_MINUS_MEAN > 0
//                      P2_SUBMODE_2<<4|
//                      P2_MODE_ADD,
//  #else
//                      P2_SUBMODE_0<<4|
//                      P2_MODE_DMA,
//  #endif
//    //jumpCnt,interCnt
//    .paraALG.alg3.p2Cfg1 = (UDFDEF_ANT_NUM-1)<< 12 |(UDFDEF_RANGE_USE-1)<< 0, // fft2d ant1 ant2
//    //ncoMode,nco_fcw
//    .paraALG.alg3.p2Cfg2 = (0)<< 24 |(0)<< 0,
//    //src0JumpInc,src0InterInc
//    .paraALG.alg3.p2Cfg3 = (UDFDEF_ADDR_FFT1D_ANT2-UDFDEF_ADDR_FFT1D_ANT1  )<<16 |(NUM_BYTE32)<< 0,
//    //src0IntraInc,src0BaseAddr
//    .paraALG.alg3.p2Cfg4 = (UDFDEF_RANGE_USE*NUM_BYTE32)<<16 |(GET_OFFSET(UDFDEF_ADDR_FFT1D_ANT1))<< 0,
//    //src1JumpInc,src1InterInc
//    .paraALG.alg3.p2Cfg5 = (UDFDEF_ADDR_FFT1D_MEAN_ANT2-UDFDEF_ADDR_FFT1D_MEAN_ANT1  )<<16 |(NUM_BYTE32)<< 0,
//    //src1IntraInc,src1BaseAddr
//    .paraALG.alg3.p2Cfg6 = (0 )<<16 |(GET_OFFSET(UDFDEF_ADDR_FFT1D_MEAN_ANT1))<< 0,
//    //dstJumpInc,dstInterInc
//    .paraALG.alg3.p2Cfg7 = (UDFDEF_ADDR_FFT2D_ANT2-UDFDEF_ADDR_FFT2D_ANT1 )<<16 |(NUM_BYTE32)<< 0,
//    //dstIntraInc,dstBaseAddr
//    .paraALG.alg3.p2Cfg8 = (UDFDEF_RANGE_USE*NUM_BYTE32)<<16 |(GET_OFFSET(UDFDEF_ADDR_FFT2D_ANT1))<< 0,
//    //inPt,fftPt,mode
//  #if (UDFDEF_VEL_NUM == 32)
//  .paraALG.alg3.fftCfg0 = (UDFDEF_CHIRP_NUM-1)<< 8 |(FFT_PT32)<< 4|(FFT_MODE_FORWARD)<<0,
//  #elif (UDFDEF_VEL_NUM == 16)
//  .paraALG.alg3.fftCfg0 = (UDFDEF_CHIRP_NUM-1)<< 8 |(FFT_PT16)<< 4|(FFT_MODE_FORWARD)<<0,
//  #elif (UDFDEF_VEL_NUM == 8)
//  .paraALG.alg3.fftCfg0 = (UDFDEF_CHIRP_NUM-1)<< 8 |(FFT_PT16)<< 4|(FFT_MODE_FORWARD)<<0,
//  #else
//  #error unxxx
//  #endif
//    //useA,useB
//    .paraALG.alg3.fftCfg1 = (0)<< 8 |(UDFDEF_VEL_NUM-1)<< 0,
//    //winBaseAddr,winSize,winEn
//  #ifdef WINVEL_ENABLE
//    .paraALG.alg3.fftCfg2 = (uint32_t)(GET_OFFSET(UDFDEF_ADDR_WIN_VEL))<<16|(FFT_WIN_SIZE_14BIT)<< 1 |(FFT_WIN_EN)<< 0,
//  #else
//  .paraALG.alg3.fftCfg2 = (uint32_t)(GET_OFFSET(UDFDEF_ADDR_WIN_VEL))<<16|(FFT_WIN_SIZE_14BIT)<< 1 |(FFT_WIN_DIS)<< 0,
//  #endif
//  #endif

#if 1 /*alg4*/ //fft2d ant2
.paraALG.alg4.p2Cfg0 = ( UDFDEF_CHIRP_NUM - 1 ) << 20 |
P2_FIX2PF_LSFB_0BIT << 17 |
P2_MAX_CLR_EN << 16 |
P2_FFT_MODE_EN << 14 |
P2_DMA_DSIZE_32BIT << 12 |
P2_RSF_DIV1 << 8 |
#if FFT2D_MINUS_MEAN > 0
P2_SUBMODE_2 << 4 |
P2_MODE_ADD,
#else
P2_SUBMODE_0 << 4 |
P2_MODE_DMA,
#endif
//jumpCnt,interCnt
.paraALG.alg4.p2Cfg1 = ( 1 - 1 ) << 12 | ( UDFDEF_RANGE_USE - 1 ) << 0,
//ncoMode,nco_fcw
.paraALG.alg4.p2Cfg2 = ( 0 ) << 24 | ( 0 ) << 0,
//src0JumpInc,src0InterInc
.paraALG.alg4.p2Cfg3 = ( 0 ) << 16 | ( NUM_BYTE32 ) << 0,
//src0IntraInc,src0BaseAddr
.paraALG.alg4.p2Cfg4 = ( UDFDEF_RANGE_USE *NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_FFT1D_ANT2 ) ) << 0,
//src1JumpInc,src1InterInc
.paraALG.alg4.p2Cfg5 = ( 0 ) << 16 | ( NUM_BYTE32 ) << 0,
//src1IntraInc,src1BaseAddr
.paraALG.alg4.p2Cfg6 = ( 0 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_FFT1D_MEAN_ANT2 ) ) << 0,
//dstJumpInc,dstInterInc
.paraALG.alg4.p2Cfg7 = ( 0 ) << 16 | ( NUM_BYTE32 ) << 0,
//dstIntraInc,dstBaseAddr
.paraALG.alg4.p2Cfg8 = ( UDFDEF_RANGE_USE *NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_FFT2D_ANT2 ) ) << 0,
//inPt,fftPt,mode
#if (UDFDEF_VEL_NUM == 32)
.paraALG.alg4.fftCfg0 = ( UDFDEF_CHIRP_NUM - 1 ) << 8 | ( FFT_PT32 ) << 4 | ( FFT_MODE_FORWARD ) << 0,
#elif (UDFDEF_VEL_NUM == 16)
.paraALG.alg4.fftCfg0 = ( UDFDEF_CHIRP_NUM - 1 ) << 8 | ( FFT_PT16 ) << 4 | ( FFT_MODE_FORWARD ) << 0,
#else
#error unxxx
#endif
//useA,useB
.paraALG.alg4.fftCfg1 = ( 0 ) << 8 | ( UDFDEF_VEL_NUM - 1 ) << 0,
//winBaseAddr,winSize,winEn
#ifdef WINVEL_ENABLE
.paraALG.alg4.fftCfg2 = ( uint32_t )( GET_OFFSET( UDFDEF_ADDR_WIN_VEL ) ) << 16 | ( FFT_WIN_SIZE_14BIT ) << 1 | ( FFT_WIN_EN ) << 0,
#else
.paraALG.alg4.fftCfg2 = ( uint32_t )( GET_OFFSET( UDFDEF_ADDR_WIN_VEL ) ) << 16 | ( FFT_WIN_SIZE_14BIT ) << 1 | ( FFT_WIN_DIS ) << 0,
#endif
#endif

#if 1 /*alg5 fft1d_ant2 * calib_ap */
// intraCnt,fix2pfLsfB,max_clr,p2_fft_mode,dma_dsize,rsfBit,sub_mode,mode
.paraALG.alg5.p2Cfg0 = ( UDFDEF_RANGE_USE - 1 ) << 20 |
P2_FIX2PF_LSFB_0BIT << 17 |
P2_MAX_CLR_EN << 16 |
P2_FFT_MODE_DIS << 14 |
P2_DMA_DSIZE_32BIT << 12 |
P2_RSF_DIV1 << 8 |
P2_SUBMODE_0 << 4 |
P2_MODE_MUL,
//jumpCnt,interCnt
.paraALG.alg5.p2Cfg1 = ( 0 ) << 12 | ( 0 ) << 0,
//ncoMode,nco_fcw
.paraALG.alg5.p2Cfg2 = ( 0 ) << 24 | ( 0 ) << 0,
//src0JumpInc,src0InterInc
.paraALG.alg5.p2Cfg3 = ( 0 ) << 16 | ( 0 ) << 0,
//src0IntraInc,src0BaseAddr
.paraALG.alg5.p2Cfg4 = ( NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_FFT1D_ANT2 ) ) << 0,
//src1JumpInc,src1InterInc
.paraALG.alg5.p2Cfg5 = ( 0 ) << 16 | ( 0 ) << 0,
//src1IntraInc,src1BaseAddr
.paraALG.alg5.p2Cfg6 = ( 0 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_ANT2_AP_PSF ) ) << 0,
//dstJumpInc,dstInterInc
.paraALG.alg5.p2Cfg7 = ( 0 ) << 16 | ( 0 ) << 0,
//dstIntraInc,dstBaseAddr
.paraALG.alg5.p2Cfg8 = ( NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_FFT1D_CALIB_ANT2 ) ) << 0,
#endif

#if 1 /*alg6 ant1+ant2 */
// intraCnt,fix2pfLsfB,max_clr,p2_fft_mode,dma_dsize,rsfBit,sub_mode,mode
.paraALG.alg6.p2Cfg0 = ( UDFDEF_RANGE_USE - 1 ) << 20 |
P2_FIX2PF_LSFB_0BIT << 17 |
P2_MAX_CLR_EN << 16 |
P2_FFT_MODE_DIS << 14 |
P2_DMA_DSIZE_32BIT << 12 |
P2_RSF_DIV1 << 8 |
P2_SUBMODE_0 << 4 |
P2_MODE_ADD,
//jumpCnt,interCnt
.paraALG.alg6.p2Cfg1 = ( 0 ) << 12 | ( 0 ) << 0,
//ncoMode,nco_fcw
.paraALG.alg6.p2Cfg2 = ( 0 ) << 24 | ( 0 ) << 0,
//src0JumpInc,src0InterInc
.paraALG.alg6.p2Cfg3 = ( 0 ) << 16 | ( 0 ) << 0,
//src0IntraInc,src0BaseAddr
.paraALG.alg6.p2Cfg4 = ( NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_FFT1D_ANT1 ) ) << 0,
//src1JumpInc,src1InterInc
.paraALG.alg6.p2Cfg5 = ( 0 ) << 16 | ( 0 ) << 0,
//src1IntraInc,src1BaseAddr
.paraALG.alg6.p2Cfg6 = ( NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_FFT1D_CALIB_ANT2 ) ) << 0,
//dstJumpInc,dstInterInc
.paraALG.alg6.p2Cfg7 = ( 0 ) << 16 | ( 0 ) << 0,
//dstIntraInc,dstBaseAddr
.paraALG.alg6.p2Cfg8 = ( NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_FFT1D_ANT1_ADD_ANT2_TMP ) ) << 0,
#endif

#if 1 /*alg7 ant1-ant2 */
// intraCnt,fix2pfLsfB,max_clr,p2_fft_mode,dma_dsize,rsfBit,sub_mode,mode
.paraALG.alg7.p2Cfg0 = ( UDFDEF_RANGE_USE - 1 ) << 20 |
P2_FIX2PF_LSFB_0BIT << 17 |
P2_MAX_CLR_EN << 16 |
P2_FFT_MODE_DIS << 14 |
P2_DMA_DSIZE_32BIT << 12 |
P2_RSF_DIV1 << 8 |
P2_SUBMODE_2 << 4 |
P2_MODE_ADD,
//jumpCnt,interCnt
.paraALG.alg7.p2Cfg1 = ( 0 ) << 12 | ( 0 ) << 0,
//ncoMode,nco_fcw
.paraALG.alg7.p2Cfg2 = ( 0 ) << 24 | ( 0 ) << 0,
//src0JumpInc,src0InterInc
.paraALG.alg7.p2Cfg3 = ( 0 ) << 16 | ( 0 ) << 0,
//src0IntraInc,src0BaseAddr
.paraALG.alg7.p2Cfg4 = ( NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_FFT1D_ANT1 ) ) << 0,
//src1JumpInc,src1InterInc
.paraALG.alg7.p2Cfg5 = ( 0 ) << 16 | ( 0 ) << 0,
//src1IntraInc,src1BaseAddr
.paraALG.alg7.p2Cfg6 = ( NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_FFT1D_CALIB_ANT2 ) ) << 0,
//dstJumpInc,dstInterInc
.paraALG.alg7.p2Cfg7 = ( 0 ) << 16 | ( 0 ) << 0,
//dstIntraInc,dstBaseAddr
.paraALG.alg7.p2Cfg8 = ( NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_FFT1D_ANT1_MINUS_ANT2_TMP ) ) << 0,
#endif

#if 0 /*alg8 adc_minus->fft1d */
//intraCnt,fix2pfLsfB,max_clr,p2_fft_mode,dma_dsize,rsfBit,sub_mode,mode
.paraALG.alg8.p2Cfg0 = ( UDFDEF_ADCSAMP_NUM - 1 ) << 20 |
P2_FIX2PF_LSFB_0BIT << 17 |
P2_MAX_CLR_EN << 16 |
P2_FFT_MODE_EN << 14 |
P2_DMA_DSIZE_32BIT << 12 |
P2_RSF_DIV1 << 8 |
P2_SUBMODE_2 << 4 |
P2_MODE_ADD,
//jumpCnt,interCnt
.paraALG.alg8.p2Cfg1 = ( 1 - 1 ) << 12 | ( UDFDEF_ANT_NUM - 1 ) << 0,
//ncoMode,nco_fcw
.paraALG.alg8.p2Cfg2 = ( 0 ) << 24 | ( 0 ) << 0,
//src0JumpInc,src0InterInc
.paraALG.alg8.p2Cfg3 = ( UDFDEF_ADCSAMP_NUM *NUM_BYTE32 *UDFDEF_ANT_NUM ) << 16 | ( UDFDEF_ADCSAMP_NUM *NUM_BYTE32 ) << 0,
//src0IntraInc,src0BaseAddr
.paraALG.alg8.p2Cfg4 = ( NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_CHIRPSUM ) ) << 0,
//src1JumpInc,src1InterInc
.paraALG.alg8.p2Cfg5 = ( 0 ) << 16 | ( UDFDEF_ADCSAMP_NUM *NUM_BYTE32 ) << 0,
//src1IntraInc,src1BaseAddr
.paraALG.alg8.p2Cfg6 = ( NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_CHIRPSUM_TEMP ) ) << 0,
//dstJumpInc,dstInterInc
.paraALG.alg8.p2Cfg7 = ( UDFDEF_RANGE_USE *NUM_BYTE32 ) << 16 | ( UDFDEF_ADDR_FFT1D_ANT2 - UDFDEF_ADDR_FFT1D_ANT1 ) << 0,
//dstIntraInc,dstBaseAddr
.paraALG.alg8.p2Cfg8 = ( NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_FFT1D_ANT1 ) ) << 0,

//inPt,fftPt,mode
.paraALG.alg8.fftCfg0 = ( UDFDEF_ADCSAMP_NUM - 1 ) << 8 | ( UDFDEF_FFT_PT ) << 4 | ( FFT_MODE_FORWARD ) << 0,
//useA,useB
.paraALG.alg8.fftCfg1 = ( 0 ) << 8 | ( UDFDEF_RANGE_USE - 1 ) << 0,
//winBaseAddr,winSize,winEn
#ifdef WINRANGE_ENABLE
.paraALG.alg8.fftCfg2 = ( uint32_t )( GET_OFFSET( UDFDEF_ADDR_WIN_RANGE ) ) << 16 | ( FFT_WIN_SIZE_14BIT ) << 1 | ( FFT_WIN_EN ) << 0,
#else
.paraALG.alg8.fftCfg2 = ( uint32_t )( GET_OFFSET( UDFDEF_ADDR_WIN_RANGE ) ) << 16 | ( FFT_WIN_SIZE_14BIT ) << 1 | ( FFT_WIN_DIS ) << 0,
#endif
.paraALG.alg8.dstInc  = UDFDEF_RANGE_USE * NUM_BYTE32,
#endif

#if 0 /*alg9  radar1: adc_minus->fft1d_diff */
//intraCnt,fix2pfLsfB,max_clr,p2_fft_mode,dma_dsize,rsfBit,sub_mode,mode
.paraALG.alg9.p2Cfg0 = ( UDFDEF_ADCSAMP_NUM - 1 ) << 20 |
P2_FIX2PF_LSFB_0BIT << 17 |
P2_MAX_CLR_EN << 16 |
P2_FFT_MODE_EN << 14 |
P2_DMA_DSIZE_32BIT << 12 |
P2_RSF_DIV1 << 8 |
P2_SUBMODE_2 << 4 |
P2_MODE_ADD,
//jumpCnt,interCnt
.paraALG.alg9.p2Cfg1 = ( 1 - 1 ) << 12 | ( UDFDEF_ANT_NUM - 1 ) << 0,
//ncoMode,nco_fcw
.paraALG.alg9.p2Cfg2 = ( 0 ) << 24 | ( 0 ) << 0,
//src0JumpInc,src0InterInc
.paraALG.alg9.p2Cfg3 = ( UDFDEF_ADCSAMP_NUM *NUM_BYTE32 *UDFDEF_ANT_NUM ) << 16 | ( UDFDEF_ADCSAMP_NUM *NUM_BYTE32 ) << 0,
//src0IntraInc,src0BaseAddr
.paraALG.alg9.p2Cfg4 = ( NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_CHIRPSUM ) ) << 0,
//src1JumpInc,src1InterInc
.paraALG.alg9.p2Cfg5 = ( 0 ) << 16 | ( UDFDEF_ADCSAMP_NUM *NUM_BYTE32 ) << 0,
//src1IntraInc,src1BaseAddr
.paraALG.alg9.p2Cfg6 = ( NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_CHIRPSUM_NOW ) ) << 0,
//dstJumpInc,dstInterInc
.paraALG.alg9.p2Cfg7 = ( UDFDEF_RANGE_USE *NUM_BYTE32 ) << 16 | ( UDFDEF_ADDR_FFT1D_DIFF_ANT2 - UDFDEF_ADDR_FFT1D_DIFF_ANT1 ) << 0,
//dstIntraInc,dstBaseAddr
.paraALG.alg9.p2Cfg8 = ( NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_FFT1D_DIFF_ANT1 ) ) << 0,

//inPt,fftPt,mode
.paraALG.alg9.fftCfg0 = ( UDFDEF_ADCSAMP_NUM - 1 ) << 8 | ( UDFDEF_FFT_PT ) << 4 | ( FFT_MODE_FORWARD ) << 0,
//useA,useB
.paraALG.alg9.fftCfg1 = ( 0 ) << 8 | ( UDFDEF_RANGE_USE - 1 ) << 0,
//winBaseAddr,winSize,winEn
#ifdef WINRANGE_ENABLE
.paraALG.alg9.fftCfg2 = ( uint32_t )( GET_OFFSET( UDFDEF_ADDR_WIN_RANGE ) ) << 16 | ( FFT_WIN_SIZE_14BIT ) << 1 | ( FFT_WIN_EN ) << 0,
#else
.paraALG.alg9.fftCfg2 = ( uint32_t )( GET_OFFSET( UDFDEF_ADDR_WIN_RANGE ) ) << 16 | ( FFT_WIN_SIZE_14BIT ) << 1 | ( FFT_WIN_DIS ) << 0,
#endif
.paraALG.alg9.dstInc  = UDFDEF_RANGE_USE * NUM_BYTE32,
#endif

#if 1 /*alg13 fft1d diff */
// intraCnt,fix2pfLsfB,max_clr,p2_fft_mode,dma_dsize,rsfBit,sub_mode,mode
.paraALG.alg13.p2Cfg0 = ( UDFDEF_RANGE_USE - 1 ) << 20 |
P2_FIX2PF_LSFB_0BIT << 17 |
P2_MAX_CLR_EN << 16 |
P2_FFT_MODE_DIS << 14 |
P2_DMA_DSIZE_32BIT << 12 |
P2_RSF_DIV1 << 8 |
P2_SUBMODE_2 << 4 |
P2_MODE_ADD,
//jumpCnt,interCnt
.paraALG.alg13.p2Cfg1 = ( 0 ) << 12 | ( 0 ) << 0,
//ncoMode,nco_fcw
.paraALG.alg13.p2Cfg2 = ( 0 ) << 24 | ( 0 ) << 0,
//src0JumpInc,src0InterInc
.paraALG.alg13.p2Cfg3 = ( 0 ) << 16 | ( 0 ) << 0,
//src0IntraInc,src0BaseAddr
.paraALG.alg13.p2Cfg4 = ( NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_FFT1D_ANT1 ) ) << 0,
//src1JumpInc,src1InterInc
.paraALG.alg13.p2Cfg5 = ( 0 ) << 16 | ( 0 ) << 0,
//src1IntraInc,src1BaseAddr
.paraALG.alg13.p2Cfg6 = ( NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_FFT1D_CALIB_ANT2 ) ) << 0,
//dstJumpInc,dstInterInc
.paraALG.alg13.p2Cfg7 = ( 0 ) << 16 | ( 0 ) << 0,
//dstIntraInc,dstBaseAddr
.paraALG.alg13.p2Cfg8 = ( NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_FFT1D_ANT1_MINUS_ANT2_TMP ) ) << 0,
#endif

#define ALG11_CFAR_CIRCLE
#if 1 /* alg11 range-cfar ant1*/
//pdEn,cfarMode,wkMode
.paraALG.alg11_cfar2.cfarCfg0 = ( CFAR_PEAKDET_DIS ) << 8 | ( CFAR_CFARMODE_SO ) << 4 | ( CFAR_WKMODE_CFAR ) << 0,
//interCnt,intraCnt
.paraALG.alg11_cfar2.cfarCfg1 = ( UDFDEF_VEL_NUM ) << 12 | ( UDFDEF_RANGE_USE ) << 0,
//wrapDirA,wrapDirB,thresDiv,divFac,mulFac,searchSize,guardSize
#if defined(ALG11_CFAR_CIRCLE)
.paraALG.alg11_cfar2.cfarCfg2 = ( 0 )  << 25 | ( 0 )  << 24 | ( UDFDEF_CFAR_R_THRESDIV )  << 20 | ( CFAR_DIVFAC1 ) << 16 | ( UDFDEF_CFAR_RTH ) << 8 | ( UDFDEF_CFAR_RS ) << 4 | ( UDFDEF_CFAR_RG ) << 0, //default:2
#else
.paraALG.alg11_cfar2.cfarCfg2 = ( 1 )  << 25 | ( 1 )  << 24 | ( UDFDEF_CFAR_R_THRESDIV )  << 20 | ( CFAR_DIVFAC1 ) << 16 | ( UDFDEF_CFAR_RTH ) << 8 | ( UDFDEF_CFAR_RS ) << 4 | ( UDFDEF_CFAR_RG ) << 0, //default:2
#endif

//cutThres
.paraALG.alg11_cfar2.cfarCfg3 = ( 0 ) << 0,
//targetLim
.paraALG.alg11_cfar2.cfarCfg4 = ( CFAR_MAX_NUM - 1 ) << 0,
//srcInterInc
.paraALG.alg11_cfar2.cfarCfg5 = ( UDFDEF_SIZE_FFT1D_PER_CHIRP_ANT ) << 0,
//srcIntraInc,srcBaseAddr
.paraALG.alg11_cfar2.cfarCfg6 = ( NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_FFT2D_ANT1 ) ) << 0,
//wrapAddrA,wrapAddrB
#if defined(ALG11_CFAR_CIRCLE)
.paraALG.alg11_cfar2.cfarCfg7 = ( uint32_t )( GET_OFFSET( UDFDEF_ADDR_FFT2D_ANT1 ) + ( UDFDEF_RANGE_USE - UDFDEF_CFAR_RS - UDFDEF_CFAR_RG ) * NUM_BYTE32 ) << 16 |
( GET_OFFSET( UDFDEF_ADDR_FFT2D_ANT1 ) ) << 0,
#else
.paraALG.alg11_cfar2.cfarCfg7 = ( uint32_t )( GET_OFFSET( UDFDEF_ADDR_FFT2D_ANT1 ) + ( UDFDEF_CFAR_RS + UDFDEF_CFAR_RG ) * NUM_BYTE32 ) << 16 |
( GET_OFFSET( UDFDEF_ADDR_FFT2D_ANT1 ) + ( UDFDEF_RANGE_USE - 2 ) * NUM_BYTE32 ) << 0,
#endif
//dstBaseAddr
.paraALG.alg11_cfar2.cfarCfg8 = ( GET_OFFSET( UDFDEF_ADDR_CFAR2_CACHE ) ) << 0,
.paraALG.alg11_cfar2.cfarAbsAddr = UDFDEF_ADDR_FFT2D_ANT1 + BBE_ABS_OFFSET,//UDFDEF_ADDR_FFT2D+BBE_ABS_OFFSET,
#endif

#define ALG29_CFAR_CIRCLE
#if 1 /* alg29 range-cfar ant2 */
//pdEn,cfarMode,wkMode
.paraALG.alg29_cfar2.cfarCfg0 = ( CFAR_PEAKDET_DIS ) << 8 | ( CFAR_CFARMODE_SO ) << 4 | ( CFAR_WKMODE_CFAR ) << 0,
//interCnt,intraCnt
.paraALG.alg29_cfar2.cfarCfg1 = ( UDFDEF_VEL_NUM ) << 12 | ( UDFDEF_RANGE_USE ) << 0,
//wrapDirA,wrapDirB,thresDiv,divFac,mulFac,searchSize,guardSize
#if defined(ALG29_CFAR_CIRCLE)
.paraALG.alg29_cfar2.cfarCfg2 = ( 0 )  << 25 | ( 0 )  << 24 | ( UDFDEF_CFAR_R_THRESDIV )  << 20 | ( CFAR_DIVFAC1 ) << 16 | ( UDFDEF_CFAR_RTH ) << 8 | ( UDFDEF_CFAR_RS ) << 4 | ( UDFDEF_CFAR_RG ) << 0, //default:2
#else
.paraALG.alg29_cfar2.cfarCfg2 = ( 1 )  << 25 | ( 1 )  << 24 | ( UDFDEF_CFAR_R_THRESDIV )  << 20 | ( CFAR_DIVFAC1 ) << 16 | ( UDFDEF_CFAR_RTH ) << 8 | ( UDFDEF_CFAR_RS ) << 4 | ( UDFDEF_CFAR_RG ) << 0, //default:2
#endif

//cutThres
.paraALG.alg29_cfar2.cfarCfg3 = ( 0 ) << 0,
//targetLim
.paraALG.alg29_cfar2.cfarCfg4 = ( CFAR_MAX_NUM - 1 ) << 0,
//srcInterInc
.paraALG.alg29_cfar2.cfarCfg5 = ( UDFDEF_SIZE_FFT1D_PER_CHIRP_ANT ) << 0,
//srcIntraInc,srcBaseAddr
.paraALG.alg29_cfar2.cfarCfg6 = ( NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_FFT2D_ANT2 ) ) << 0,
//wrapAddrA,wrapAddrB
#if defined(ALG29_CFAR_CIRCLE)
.paraALG.alg29_cfar2.cfarCfg7 = ( uint32_t )( GET_OFFSET( UDFDEF_ADDR_FFT2D_ANT2 ) + ( UDFDEF_RANGE_USE - UDFDEF_CFAR_RS - UDFDEF_CFAR_RG ) * NUM_BYTE32 ) << 16 |
( GET_OFFSET( UDFDEF_ADDR_FFT2D_ANT2 ) ) << 0,
#else
.paraALG.alg29_cfar2.cfarCfg7 = ( uint32_t )( GET_OFFSET( UDFDEF_ADDR_FFT2D_ANT2 ) + ( UDFDEF_CFAR_RS + UDFDEF_CFAR_RG ) * NUM_BYTE32 ) << 16 |
( GET_OFFSET( UDFDEF_ADDR_FFT2D_ANT2 ) + ( UDFDEF_RANGE_USE - 2 ) * NUM_BYTE32 ) << 0,
#endif
//dstBaseAddr
.paraALG.alg29_cfar2.cfarCfg8 = ( GET_OFFSET( UDFDEF_ADDR_CFAR2_CACHE ) ) << 0,
.paraALG.alg29_cfar2.cfarAbsAddr = UDFDEF_ADDR_FFT2D_ANT2 + BBE_ABS_OFFSET,//UDFDEF_ADDR_FFT2D+BBE_ABS_OFFSET,
#endif

#if 1 /* alg10 range-cfar ant1*/
#define ALG10_CFAR_CIRCLE
//pdEn,cfarMode,wkMode
.paraALG.alg10_cfar1.cfarCfg0 = ( CFAR_PEAKDET_DIS ) << 8 | ( CFAR_CFARMODE_SO ) << 4 | ( CFAR_WKMODE_CFAR ) << 0,
//interCnt,intraCnt
.paraALG.alg10_cfar1.cfarCfg1 = ( UDFDEF_MOTION_CHIRP_NUM ) << 12 | ( UDFDEF_RANGE_USE ) << 0,
//wrapDirA,wrapDirB,thresDiv,divFac,mulFac,searchSize,guardSize
#if defined(ALG10_CFAR_CIRCLE)
.paraALG.alg10_cfar1.cfarCfg2 = ( 0 )  << 25 | ( 0 )  << 24 | ( UDFDEF_CFAR_MOTION_R_THRESDIV )  << 20 | ( CFAR_DIVFAC1 ) << 16 | ( UDFDEF_CFAR_MOTION_RTH ) << 8 | ( UDFDEF_CFAR_MOTION_RS ) << 4 | ( UDFDEF_CFAR_MOTION_RG ) << 0, //default:2
#else
.paraALG.alg10_cfar1.cfarCfg2 = ( 1 )  << 25 | ( 1 )  << 24 | ( UDFDEF_CFAR_MOTION_R_THRESDIV )  << 20 | ( CFAR_DIVFAC1 ) << 16 | ( UDFDEF_CFAR_MOTION_RTH ) << 8 | ( UDFDEF_CFAR_MOTION_RS ) << 4 | ( UDFDEF_CFAR_MOTION_RG ) << 0, //default:2
#endif

//cutThres
.paraALG.alg10_cfar1.cfarCfg3 = ( 0 ) << 0,
//targetLim
.paraALG.alg10_cfar1.cfarCfg4 = ( CFAR_MAX_NUM - 1 ) << 0,
//srcInterInc
.paraALG.alg10_cfar1.cfarCfg5 = ( UDFDEF_SIZE_FFT1D_PER_CHIRP_ANT ) << 0,
//srcIntraInc,srcBaseAddr
.paraALG.alg10_cfar1.cfarCfg6 = ( NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_FFT1D_DIFF_ANT1 ) ) << 0,
//wrapAddrA,wrapAddrB
#if defined(ALG10_CFAR_CIRCLE)
.paraALG.alg10_cfar1.cfarCfg7 = ( uint32_t )( GET_OFFSET( UDFDEF_ADDR_FFT1D_DIFF_ANT1 ) + ( UDFDEF_RANGE_USE - UDFDEF_CFAR_MOTION_RS - UDFDEF_CFAR_MOTION_RG ) * NUM_BYTE32 ) << 16 |
( GET_OFFSET( UDFDEF_ADDR_FFT1D_DIFF_ANT1 ) ) << 0,
#else
.paraALG.alg10_cfar1.cfarCfg7 = ( uint32_t )( GET_OFFSET( UDFDEF_ADDR_FFT1D_DIFF_ANT1 ) + ( UDFDEF_CFAR_MOTION_RS + UDFDEF_CFAR_MOTION_RG ) * NUM_BYTE32 ) << 16 |
( GET_OFFSET( UDFDEF_ADDR_FFT1D_DIFF_ANT1 ) + ( UDFDEF_RANGE_USE - 2 ) * NUM_BYTE32 ) << 0,
#endif
//dstBaseAddr
.paraALG.alg10_cfar1.cfarCfg8 = ( GET_OFFSET( UDFDEF_ADDR_CFAR2_CACHE ) ) << 0,
.paraALG.alg10_cfar1.cfarAbsAddr = UDFDEF_ADDR_FFT1D_DIFF_ANT1 + BBE_ABS_OFFSET,//UDFDEF_ADDR_FFT2D+BBE_ABS_OFFSET,
#endif

#if 0 /* alg10 vel-cfar ant1 */
// pdEn,cfarMode,wkMode
.paraALG.alg10_cfar1.cfarCfg0 = ( CFAR_PEAKDET_DIS ) << 8 | ( CFAR_CFARMODE_SO ) << 4 | ( CFAR_WKMODE_CFAR ) << 0,
// interCnt,intraCnt
.paraALG.alg10_cfar1.cfarCfg1 = ( UDFDEF_RANGE_USE ) << 12 | ( UDFDEF_VEL_NUM ) << 0,
// wrapDirA,wrapDirB,thresDiv,divFac,mulFac,searchSize,guardSize
.paraALG.alg10_cfar1.cfarCfg2 = ( 0 ) << 25 | ( 0 ) << 24 | ( UDFDEF_CFAR_V_THRESDIV ) << 20 | ( CFAR_DIVFAC1 ) << 16 | ( UDFDEF_CFAR_VTH ) << 8 | ( UDFDEF_CFAR_VS ) << 4 | ( UDFDEF_CFAR_VG ) << 0,
// cutThres
.paraALG.alg10_cfar1.cfarCfg3 = ( 0 ) << 0,
// targetLim
.paraALG.alg10_cfar1.cfarCfg4 = ( CFAR_MAX_NUM - 1 ) << 0,
// srcInterInc
.paraALG.alg10_cfar1.cfarCfg5 = ( NUM_BYTE32 ) << 0,
// srcIntraInc,srcBaseAddr
.paraALG.alg10_cfar1.cfarCfg6 = ( UDFDEF_RANGE_USE *NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_FFT2D_ANT1 ) ) << 0, // ant1
// wrapAddrA,wrapAddrB
.paraALG.alg10_cfar1.cfarCfg7 = ( uint32_t )( GET_OFFSET( UDFDEF_ADDR_FFT2D_ANT1 ) + ( UDFDEF_VEL_NUM - UDFDEF_CFAR_VS - UDFDEF_CFAR_VG ) * UDFDEF_RANGE_USE *NUM_BYTE32 ) << 16 \
| ( GET_OFFSET( UDFDEF_ADDR_FFT2D_ANT1 ) ) << 0,

// dstBaseAddr
.paraALG.alg10_cfar1.cfarCfg8 = ( GET_OFFSET( UDFDEF_ADDR_CFAR1_CACHE ) ) << 0,
.paraALG.alg10_cfar1.cfarAbsAddr = UDFDEF_ADDR_FFT2D_ANT1 + BBE_ABS_OFFSET,
#endif

#if 1 /* alg28 range-cfar ant2 */
#define ALG28_CFAR_CIRCLE
//pdEn,cfarMode,wkMode
.paraALG.alg28_cfar1.cfarCfg0 = ( CFAR_PEAKDET_DIS ) << 8 | ( CFAR_CFARMODE_SO ) << 4 | ( CFAR_WKMODE_CFAR ) << 0,
//interCnt,intraCnt
.paraALG.alg28_cfar1.cfarCfg1 = ( UDFDEF_MOTION_CHIRP_NUM ) << 12 | ( UDFDEF_RANGE_USE ) << 0,
//wrapDirA,wrapDirB,thresDiv,divFac,mulFac,searchSize,guardSize
#if defined(ALG28_CFAR_CIRCLE)
.paraALG.alg28_cfar1.cfarCfg2 = ( 0 )  << 25 | ( 0 )  << 24 | ( UDFDEF_CFAR_MOTION_R_THRESDIV )  << 20 | ( CFAR_DIVFAC1 ) << 16 | ( UDFDEF_CFAR_MOTION_RTH ) << 8 | ( UDFDEF_CFAR_MOTION_RS ) << 4 | ( UDFDEF_CFAR_MOTION_RG ) << 0, //default:2
#else
.paraALG.alg28_cfar1.cfarCfg2 = ( 1 )  << 25 | ( 1 )  << 24 | ( UDFDEF_CFAR_MOTION_R_THRESDIV )  << 20 | ( CFAR_DIVFAC1 ) << 16 | ( UDFDEF_CFAR_MOTION_RTH ) << 8 | ( UDFDEF_CFAR_MOTION_RS ) << 4 | ( UDFDEF_CFAR_MOTION_RG ) << 0, //default:2
#endif

//cutThres
.paraALG.alg28_cfar1.cfarCfg3 = ( 0 ) << 0,
//targetLim
.paraALG.alg28_cfar1.cfarCfg4 = ( CFAR_MAX_NUM - 1 ) << 0,
//srcInterInc
.paraALG.alg28_cfar1.cfarCfg5 = ( UDFDEF_SIZE_FFT1D_PER_CHIRP_ANT ) << 0,
//srcIntraInc,srcBaseAddr
.paraALG.alg28_cfar1.cfarCfg6 = ( NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_FFT1D_DIFF_ANT2 ) ) << 0,
//wrapAddrA,wrapAddrB
#if defined(ALG28_CFAR_CIRCLE)
.paraALG.alg28_cfar1.cfarCfg7 = ( uint32_t )( GET_OFFSET( UDFDEF_ADDR_FFT1D_DIFF_ANT2 ) + ( UDFDEF_RANGE_USE - UDFDEF_CFAR_MOTION_RS - UDFDEF_CFAR_MOTION_RG ) * NUM_BYTE32 ) << 16 |
( GET_OFFSET( UDFDEF_ADDR_FFT1D_DIFF_ANT2 ) ) << 0,
#else
.paraALG.alg28_cfar1.cfarCfg7 = ( uint32_t )( GET_OFFSET( UDFDEF_ADDR_FFT1D_DIFF_ANT2 ) + ( UDFDEF_CFAR_MOTION_RS + UDFDEF_CFAR_MOTION_RG ) * NUM_BYTE32 ) << 16 |
( GET_OFFSET( UDFDEF_ADDR_FFT1D_DIFF_ANT2 ) + ( UDFDEF_RANGE_USE - 2 ) * NUM_BYTE32 ) << 0,
#endif
//dstBaseAddr
.paraALG.alg28_cfar1.cfarCfg8 = ( GET_OFFSET( UDFDEF_ADDR_CFAR2_CACHE ) ) << 0,
.paraALG.alg28_cfar1.cfarAbsAddr = UDFDEF_ADDR_FFT1D_DIFF_ANT2 + BBE_ABS_OFFSET,//UDFDEF_ADDR_FFT2D+BBE_ABS_OFFSET,
#endif

#if 0 /*alg28*/ /* alg28 vel-cfar ant2 */
// pdEn,cfarMode,wkMode
.paraALG.alg28_cfar1.cfarCfg0 = ( CFAR_PEAKDET_DIS ) << 8 | ( CFAR_CFARMODE_SO ) << 4 | ( CFAR_WKMODE_CFAR ) << 0,
// interCnt,intraCnt
.paraALG.alg28_cfar1.cfarCfg1 = ( UDFDEF_RANGE_USE ) << 12 | ( UDFDEF_VEL_NUM ) << 0,
// wrapDirA,wrapDirB,thresDiv,divFac,mulFac,searchSize,guardSize
.paraALG.alg28_cfar1.cfarCfg2 = ( 0 ) << 25 | ( 0 ) << 24 | ( UDFDEF_CFAR_V_THRESDIV ) << 20 | ( CFAR_DIVFAC1 ) << 16 | ( UDFDEF_CFAR_VTH ) << 8 | ( UDFDEF_CFAR_VS ) << 4 | ( UDFDEF_CFAR_VG ) << 0,
// cutThres
.paraALG.alg28_cfar1.cfarCfg3 = ( 0 ) << 0,
// targetLim
.paraALG.alg28_cfar1.cfarCfg4 = ( CFAR_MAX_NUM - 1 ) << 0,
// srcInterInc
.paraALG.alg28_cfar1.cfarCfg5 = ( NUM_BYTE32 ) << 0,
// srcIntraInc,srcBaseAddr
.paraALG.alg28_cfar1.cfarCfg6 = ( UDFDEF_RANGE_USE *NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_FFT2D_ANT2 ) ) << 0, // ant1
// wrapAddrA,wrapAddrB
.paraALG.alg28_cfar1.cfarCfg7 = ( uint32_t )( GET_OFFSET( UDFDEF_ADDR_FFT2D_ANT2 ) + ( UDFDEF_VEL_NUM - UDFDEF_CFAR_VS - UDFDEF_CFAR_VG ) * UDFDEF_RANGE_USE *NUM_BYTE32 ) << 16 \
| ( GET_OFFSET( UDFDEF_ADDR_FFT2D_ANT2 ) ) << 0,

// dstBaseAddr
.paraALG.alg28_cfar1.cfarCfg8 = ( GET_OFFSET( UDFDEF_ADDR_CFAR1_CACHE ) ) << 0,
.paraALG.alg28_cfar1.cfarAbsAddr = UDFDEF_ADDR_FFT2D_ANT2 + BBE_ABS_OFFSET,
#endif

#if 1 /* alg12 ant1 fft3d pre */
.paraALG.alg12.srcAddr  = UDFDEF_ADDR_FFT1D_ANT1,
.paraALG.alg12.intraCnt = 1,
.paraALG.alg12.interCnt = UDFDEF_RANGE_USE,
.paraALG.alg12.dstAddr  = UDFDEF_ADDR_ANGLE_PRE,
#endif

#if 1 /* alg20 ant2 fft3d pre */
.paraALG.alg20.srcAddr  = UDFDEF_ADDR_FFT1D_ANT2,
.paraALG.alg20.intraCnt = 1,
.paraALG.alg20.interCnt = UDFDEF_RANGE_USE,
.paraALG.alg20.dstAddr  = UDFDEF_ADDR_ANGLE_PRE + NUM_BYTE32,
#endif


#if 1 // ALG23: 3D angle DFT
// intraCnt,fix2pfLsfB,max_clr,p2_fft_mode,dma_dsize,rsfBit,sub_mode,mode
.paraALG.alg23.p2Cfg0 = ( ANT_MAX_NUM - 1 ) << 20 |
P2_FIX2PF_LSFB_0BIT << 17 |
P2_MAX_CLR_EN << 16 |
P2_FFT_MODE_DIS << 14 |
P2_DMA_DSIZE_32BIT << 12 |
P2_RSF_DIV1 << 8 |
P2_SUBMODE_0 << 4 |
P2_MODE_MAC,
// jumpCnt,interCnt
.paraALG.alg23.p2Cfg1 = ( NUM_ANGLE - 1 ) << 12 | ( 0 ) << 0,
// ncoMode,nco_fcw
.paraALG.alg23.p2Cfg2 = ( 0 ) << 24 | ( 0 ) << 0,
// src0JumpInc,src0InterInc
.paraALG.alg23.p2Cfg3 = ( ANT_MAX_NUM *NUM_BYTE32 ) << 16 | ( 0 ) << 0, // 2条天线求角
// src0IntraInc,src0BaseAddr
.paraALG.alg23.p2Cfg4 = ( NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_ANGLE_ARRAY ) ) << 0,
// src1JumpInc,src1InterInc
.paraALG.alg23.p2Cfg5 = ( 0 ) << 16 | ( 0 ) << 0,
// src1IntraInc,src1BaseAddr
.paraALG.alg23.p2Cfg6 = ( NUM_BYTE32 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_ANGLE_PRE ) ) << 0,
// dstJumpInc,dstInterInc
.paraALG.alg23.p2Cfg7 = ( NUM_BYTE32 ) << 16 | ( 0 ) << 0,
// dstIntraInc,dstBaseAddr
.paraALG.alg23.p2Cfg8 = ( 0 ) << 16 | ( GET_OFFSET( UDFDEF_ADDR_ANGLE_RSLT ) ) << 0,
#endif

#if SDK_VERSION < SDK_VERSION_GENE(3,0)
.paraALG.algEn  = 0,
.paraALG.copyEn = 0,
.paraALG.copyFlashEn = 0,
#endif
.paraALG.crcLen = sizeof( PARAM_ALGORITHM ) - 4,
.paraALG.crcVal = UDP_ALG_CRC,
/******************************************************************************/

/**************************************paramFunc*************************/
#if SDK_VERSION >= SDK_VERSION_GENE(3,0)
.paraFunc.udf01_info.srcAddr = UDF01_SRC_ADDR, // 专用
.paraFunc.udf01_info.dstAddr = UDF_DST_ADDR + UDF01_OFFSET,
.paraFunc.udf01_info.len = UDP_UDF_LEN( 01 ),
.paraFunc.udf01_info.crc = UDP_UDF_CRC( 01 ),

.paraFunc.udf02_info.srcAddr = UDF02_SRC_ADDR, // 专用
.paraFunc.udf02_info.dstAddr = UDF_DST_ADDR + UDF02_OFFSET,
.paraFunc.udf02_info.len     = UDP_UDF_LEN( 02 ),
.paraFunc.udf02_info.crc     = UDP_UDF_CRC( 02 ),


.paraFunc.udf03_info.srcAddr = UDF03_SRC_ADDR, // 固定回调点
.paraFunc.udf03_info.dstAddr = UDF_DST_ADDR + UDF03_OFFSET,
.paraFunc.udf03_info.len     = UDP_UDF_LEN( 03 ),
.paraFunc.udf03_info.crc     = UDP_UDF_CRC( 03 ),

.paraFunc.udf04_info.srcAddr = UDF04_SRC_ADDR, // 固定回调点
.paraFunc.udf04_info.dstAddr = UDF_DST_ADDR + UDF04_OFFSET,
.paraFunc.udf04_info.len     = UDP_UDF_LEN( 04 ),
.paraFunc.udf04_info.crc     = UDP_UDF_CRC( 04 ),


.paraFunc.udf05_info.srcAddr = UDF05_SRC_ADDR,// UDF05~UDF14通用
.paraFunc.udf05_info.dstAddr = UDF_DST_ADDR + UDF05_OFFSET,
.paraFunc.udf05_info.len     = UDP_UDF_LEN( 05 ),
.paraFunc.udf05_info.crc     = UDP_UDF_CRC( 05 ),

.paraFunc.udf06_info.srcAddr = UDF06_SRC_ADDR,// UDF05~UDF14通用
.paraFunc.udf06_info.dstAddr = UDF_DST_ADDR + UDF06_OFFSET,
.paraFunc.udf06_info.len     = UDP_UDF_LEN( 06 ),
.paraFunc.udf06_info.crc     = UDP_UDF_CRC( 06 ),

.paraFunc.udf07_info.srcAddr = UDF07_SRC_ADDR,// UDF05~UDF14通用
.paraFunc.udf07_info.dstAddr = UDF_DST_ADDR + UDF07_OFFSET,
.paraFunc.udf07_info.len     = UDP_UDF_LEN( 07 ),
.paraFunc.udf07_info.crc     = UDP_UDF_CRC( 07 ),

.paraFunc.udf08_info.srcAddr = UDF08_SRC_ADDR,// UDF05~UDF14通用
.paraFunc.udf08_info.dstAddr = UDF_DST_ADDR + UDF08_OFFSET,
.paraFunc.udf08_info.len     = UDP_UDF_LEN( 08 ),
.paraFunc.udf08_info.crc     = UDP_UDF_CRC( 08 ),

.paraFunc.udf09_info.srcAddr = UDF09_SRC_ADDR,// UDF05~UDF14通用
.paraFunc.udf09_info.dstAddr = UDF_DST_ADDR + UDF09_OFFSET,
.paraFunc.udf09_info.len     = UDP_UDF_LEN( 09 ),
.paraFunc.udf09_info.crc     = UDP_UDF_CRC( 09 ),

.paraFunc.udf10_info.srcAddr = UDF10_SRC_ADDR,// UDF05~UDF14通用
.paraFunc.udf10_info.dstAddr = UDF_DST_ADDR + UDF10_OFFSET,
.paraFunc.udf10_info.len     = UDP_UDF_LEN( 10 ),
.paraFunc.udf10_info.crc     = UDP_UDF_CRC( 10 ),

.paraFunc.udf11_info.srcAddr = UDF11_SRC_ADDR,// UDF05~UDF14通用
.paraFunc.udf11_info.dstAddr = UDF_DST_ADDR + UDF11_OFFSET,
.paraFunc.udf11_info.len     = UDP_UDF_LEN( 11 ),
.paraFunc.udf11_info.crc     = UDP_UDF_CRC( 11 ),

.paraFunc.udf12_info.srcAddr = UDF12_SRC_ADDR,// UDF05~UDF14通用
.paraFunc.udf12_info.dstAddr = UDF_DST_ADDR + UDF12_OFFSET,
.paraFunc.udf12_info.len     = UDP_UDF_LEN( 12 ),
.paraFunc.udf12_info.crc     = UDP_UDF_CRC( 12 ),

.paraFunc.udf13_info.srcAddr = UDF13_SRC_ADDR,// UDF05~UDF14通用,UDF13可选运行于BBSRAM
#if defined(UDF13_AT_BB_SRAM)
.paraFunc.udf13_info.dstAddr = UDF13_AT_BB_SRAM_ADDR + UDF13_OFFSET,
#else
.paraFunc.udf13_info.dstAddr = UDF_DST_ADDR + UDF13_OFFSET,
#endif
.paraFunc.udf13_info.len     = UDP_UDF_LEN( 13 ),
.paraFunc.udf13_info.crc     = UDP_UDF_CRC( 13 ),

.paraFunc.udf14_info.srcAddr = UDF14_SRC_ADDR, // UDF05~UDF14通用
.paraFunc.udf14_info.dstAddr = UDF_DST_ADDR + UDF14_OFFSET,
.paraFunc.udf14_info.len     = UDP_UDF_LEN( 14 ),
.paraFunc.udf14_info.crc     = UDP_UDF_CRC( 14 ),

.paraFunc.udf15_info.srcAddr = UDF15_SRC_ADDR, // 专用
.paraFunc.udf15_info.dstAddr = UDF15_DST_ADDR,
.paraFunc.udf15_info.len     = UDP_UDF_LEN( 15 ),
.paraFunc.udf15_info.crc     = UDP_UDF_CRC( 15 ),

.paraFunc.udf16_info.srcAddr = UDF16_SRC_ADDR, // 中断专用
.paraFunc.udf16_info.dstAddr = UDF16_DST_ADDR,
.paraFunc.udf16_info.len     = UDP_UDF_LEN( 16 ),
.paraFunc.udf16_info.crc     = UDP_UDF_CRC( 16 ),
#else
.paraFunc.udf01_addr.srcAddr = UDF01_SRC_ADDR,
.paraFunc.udf01_addr.dstAddr = UDF_DST_ADDR + UDF01_OFFSET,
.paraFunc.udf01_len          = UDP_UDF_LEN( 01 ),

.paraFunc.udf02_addr.srcAddr = UDF02_SRC_ADDR,
.paraFunc.udf02_addr.dstAddr = UDF_DST_ADDR + UDF02_OFFSET,
.paraFunc.udf02_len          = UDP_UDF_LEN( 02 ),


.paraFunc.udf03_addr.srcAddr = UDF03_SRC_ADDR,
.paraFunc.udf03_addr.dstAddr = UDF_DST_ADDR + UDF03_OFFSET,
.paraFunc.udf03_len          = UDP_UDF_LEN( 03 ),

.paraFunc.udf04_addr.srcAddr = UDF04_SRC_ADDR,
.paraFunc.udf04_addr.dstAddr = UDF_DST_ADDR + UDF04_OFFSET,
.paraFunc.udf04_len          = UDP_UDF_LEN( 04 ),


.paraFunc.udf05_addr.srcAddr = UDF05_SRC_ADDR,
.paraFunc.udf05_addr.dstAddr = UDF_DST_ADDR + UDF05_OFFSET,
.paraFunc.udf05_len          = UDP_UDF_LEN( 05 ),


.paraFunc.udf06_addr.srcAddr = UDF06_SRC_ADDR,
.paraFunc.udf06_addr.dstAddr = UDF_DST_ADDR + UDF06_OFFSET,
.paraFunc.udf06_len          = UDP_UDF_LEN( 06 ),

.paraFunc.udf07_addr.srcAddr = UDF07_SRC_ADDR,
.paraFunc.udf07_addr.dstAddr = UDF_DST_ADDR + UDF07_OFFSET,
.paraFunc.udf07_len          = UDP_UDF_LEN( 07 ),

.paraFunc.udf08_addr.srcAddr = UDF08_SRC_ADDR,
.paraFunc.udf08_addr.dstAddr = UDF_DST_ADDR + UDF08_OFFSET,
.paraFunc.udf08_len          = UDP_UDF_LEN( 08 ),

.paraFunc.udf09_addr.srcAddr = UDF09_SRC_ADDR,
.paraFunc.udf09_addr.dstAddr = UDF_DST_ADDR + UDF09_OFFSET,
.paraFunc.udf09_len          = UDP_UDF_LEN( 09 ),

.paraFunc.udf10_addr.srcAddr = UDF10_SRC_ADDR,
.paraFunc.udf10_addr.dstAddr = UDF_DST_ADDR + UDF10_OFFSET,
.paraFunc.udf10_len          = UDP_UDF_LEN( 10 ),

.paraFunc.udf11_addr.srcAddr = UDF11_SRC_ADDR,
.paraFunc.udf11_addr.dstAddr = UDF_DST_ADDR + UDF11_OFFSET,
.paraFunc.udf11_len          = UDP_UDF_LEN( 11 ),

.paraFunc.udf12_addr.srcAddr = UDF12_SRC_ADDR,
.paraFunc.udf12_addr.dstAddr = UDF_DST_ADDR + UDF12_OFFSET,
.paraFunc.udf12_len          = UDP_UDF_LEN( 12 ),

.paraFunc.udf13_addr.srcAddr = UDF13_SRC_ADDR,
#if defined(UDF13_AT_BB_SRAM)
.paraFunc.udf13_addr.dstAddr = UDF13_AT_BB_SRAM_ADDR + UDF13_OFFSET,
#else
.paraFunc.udf13_addr.dstAddr = UDF_DST_ADDR + UDF13_OFFSET,
#endif
.paraFunc.udf13_len          = UDP_UDF_LEN( 13 ),

.paraFunc.udf14_addr.srcAddr = UDF14_SRC_ADDR,
.paraFunc.udf14_addr.dstAddr = UDF_DST_ADDR + UDF14_OFFSET,
.paraFunc.udf14_len          = UDP_UDF_LEN( 14 ),

.paraFunc.udf15_addr.srcAddr = UDF15_SRC_ADDR,
.paraFunc.udf15_addr.dstAddr = UDF_DST_ADDR + UDF15_OFFSET,
.paraFunc.udf15_len          = UDP_UDF_LEN( 15 ),

.paraFunc.udf16_addr.srcAddr = UDF16_SRC_ADDR,
.paraFunc.udf16_addr.dstAddr = UDF_DST_ADDR + UDF16_OFFSET,
.paraFunc.udf16_len          = UDP_UDF_LEN( 16 ),
#endif


//*******************************************************************************************************
.paraFunc.udfEn        = UDF_EN,

#if SDK_VERSION >= SDK_VERSION_GENE(3,0)
.paraFunc.qspiMode     = FLASH_INTERFACE,
#else
#if FLASH_INTERFACE < eQSPI_FLASH_QUAD_IO
.paraFunc.qspiMode     = 0, // 0:single-line  1:4-line
#else
.paraFunc.qspiMode     = 1, // 0:single-line  1:4-line
#endif
#endif

.paraFunc.rtcCailbClkCnt   = 8,  // 8 16 32 64 128

#if (UART_BAUDRATE == 0) && (SDK_VERSION >= SDK_VERSION_GENE(3,0)) // ROMv2不支持关闭串口
	.paraFunc.use_uart         = 0,
#elif UART_BAUDRATE == 1
	.paraFunc.baudrate         = 2000000,
#elif UART_BAUDRATE == 2
	.paraFunc.baudrate         = 115200,
#else
#error xxx
#endif
.paraFunc.AtCmdDelay       = AT_WAIT_MS,

.paraFunc.wdt_cnt          = WDT_TIMEOUT_MS * 32, // 1=31.25us   32K clock,  64000=2s 160000=5s

/* 默认PIN配置 */
#if 1

#if UART_BAUDRATE > 0
	.paraFunc.gpio_pmode     = 0x00000000,
	//.paraFunc.gpio_pmode     = 0x00000000,
	//      .paraFunc.gpio_pctrl_ue  = 0x000021C0,
	//      .paraFunc.gpio_pctrl_re  = 0x0000FFFE,     // all pull-up or pull-down but gpio0.0
	//      .paraFunc.gpio_pmux0     = 0x11000000,     // usci1
	.paraFunc.gpio_pctrl_ue  = 0x000021C0,
	.paraFunc.gpio_pctrl_re  = 0x0000FFFE,
	.paraFunc.gpio_pmux0     = 0x11000000,     // usci1
#if IS_RAMAPP > 0
	.paraFunc.gpio_pmux1     = 0x00000000,     // qspi
#else
	.paraFunc.gpio_pmux1     = 0x00666666,     // qspi
#endif
#else
	.paraFunc.gpio_pmode     = 0x00000024,
	.paraFunc.gpio_pctrl_ue  = 0x00002100,
	.paraFunc.gpio_pctrl_re  = 0x0000FFFE,
	.paraFunc.gpio_pmux0     = 0x00000000,
#if IS_RAMAPP > 0
	.paraFunc.gpio_pmux1     = 0x00000000,     // qspi
#else
	.paraFunc.gpio_pmux1     = 0x00666666,     // qspi
#endif
#endif

#endif


.paraFunc.ab_area_offset   = OTA_SIZE_MAX,

.paraFunc.crcLen           = sizeof( PARAM_FUNC ) - 4,
.paraFunc.crcVal           = UDP_FUNC_CRC,

#if SDK_VERSION >= SDK_VERSION_GENE(3,0)
.paraFunc.fw_version       = {FW_VERSION},
.paraFunc.dl_flag          = IS_RAMAPP,   // 0：非动态加载，其它：动态加载
.paraRT.startup_flag       = 1,
.paraRT.switch_flag        = 0,
.paraRT.ab_app_flag        = 0,
.paraRT.ab_cfg_flag        = 0,
.paraRT.frame_cnt          = 0,
.paraRT.sn                 = 0,

.paraRT.frame_intv_ms      = FRAME_INTV_MS * 0.94,

.paraFunc.opt_data_len     = 0,
.paraFunc.opt_data_crc     = 0,

.paraRT.crcLen             = sizeof( PARAM_RUNTIME ) - 4,
.paraRT.crcVal             = UDP_RT_CRC,

.paraFunc.funcEn           = FUNC_CRC_UDP_EN | FUNC_CRC_UDF_EN | FUNC_RTC_CALIB_DIS | FUNC_CRC_UDP_USR_CFG_EN | FUNC_VERSION_OUTPUT_EN,

#else
.paraFunc.funcEn           = FUNC_PROTOCOL_DIS | FUNC_DEBUG_DIS | FUNC_RTC_CALIB_DIS | FUNC_CRC_PATCH_EN | FUNC_SPI1_00_DIS,
// 此处后的变量在romv3中已移除，udkv2.1的应用中也应不再调用，以便于后期升级移植。
.paraFunc.frameT0_msec     = 0,
.paraFunc.frameT1_msec     = 0,
.paraFunc.uartOutputAddr   = 0,
.paraFunc.uartDebugAddr    = 0,
.paraFunc.uartDebugLen     = 0,
.paraFunc.rangeIdxTh       = 128,
.paraFunc.numTLVs          = 0,

.paraFunc.uartDebugMode    = 0,
.paraFunc.ab_area_flag     = 0,
.paraFunc.spi1_baudDiv     = 0,
.paraFunc.rtcCailbFrameCnt = 0,
.paraFunc.pro_func         = 2,
.paraFunc.rsv_crc          = UDP_CFG_CRC,
#endif
#endif

#if defined(USR_CFG_ENABLE)

#if SDK_VERSION < SDK_VERSION_GENE(3,0)
// udkv3新增变量
.paraRT.fw_version         = {FW_VERSION},
.paraRT.dl_flag            = IS_RAMAPP,// 0:非动态加载，其它：动态加载

.paraRT.startup_flag       = 1,
.paraRT.switch_flag        = 0,
.paraRT.ab_app_flag        = 0,
.paraRT.ab_cfg_flag        = 0,
.paraRT.frame_cnt          = 0,
.paraRT.sn                 = 0,

.paraRT.frame_intv_ms      = FRAME_INTV_MS * 0.94,
#endif

.paraCFG.no_target_cnt_timeout   = SEC_TO_FRAME_CNT( 2 ), // 2s

.paraCFG.trigger_range_threshold = UDFDEF_RANGE_USE,

.paraCFG.crcLen            = sizeof( PARAM_CFG ) - 4,
.paraCFG.crcVal            = UDP_CFG_CRC,
#endif
